import { ITypeEntity } from '@/types/modules/superType/types';
import { parseTsType } from '@/types/modules/editor/server/code-transformer/utils/export/parseTsType';
import { codeToApiTypeEntity } from './apiTypeParser';
import { createBaseTypeFromPath } from '../../utils/entryFactory';
import { FileTypeManager } from '../../config/file-types.config';
import { getFileInfoFromPath } from '../../utils/getFileInfoFromPath';

/**
 * 从 TypeScript 代码中解析元数据 (JSDoc 注释)
 */
function parseTypeScriptMeta(content: string): {
  title?: string;
  intro?: string;
  methods?: string[];
  [key: string]: any;
} {
  const meta: any = {};

  // 查找文件顶部的 JSDoc 注释块
  const jsdocMatch = content.match(/^\s*\/\*\*([\s\S]*?)\*\//);
  if (!jsdocMatch) {
    return meta;
  }

  const commentContent = jsdocMatch[1];
  const lines = commentContent
    .split('\n')
    .map((line) => line.trim().replace(/^\*\s?/, ''));

  let foundFirstTag = false;

  for (const line of lines) {
    if (!line) continue;

    // 处理 @tag 标签
    if (line.startsWith('@')) {
      foundFirstTag = true;

      // @methods 标签 - 云函数支持的 HTTP 方法
      const methodsMatch = line.match(/^@methods\s+(.+)$/);
      if (methodsMatch) {
        meta.methods = methodsMatch[1]
          .split(',')
          .map((m) => m.trim().toUpperCase());
        continue;
      }

      // @api 标签 - API 接口信息
      const apiMatch = line.match(/^@api\s+(\w+)\s+(.+)$/);
      if (apiMatch) {
        meta.method = apiMatch[1].toUpperCase();
        meta.uri = apiMatch[2];
        continue;
      }

      // 其他标签可以在这里扩展
      // @version, @author, @since 等
    } else if (!foundFirstTag) {
      // 在遇到第一个 @tag 之前的内容
      if (!meta.title && line) {
        meta.title = line;
      } else if (meta.title && line) {
        // 第二行及以后作为详细介绍
        meta.intro = meta.intro ? `${meta.intro}\n${line}` : line;
      }
    }
  }

  return meta;
}

/**
 * 从 Markdown 内容中解析元数据
 */
function parseMarkdownMeta(content: string): {
  title?: string;
  [key: string]: any;
} {
  const meta: any = {};

  if (!content || !content.trim()) {
    return meta;
  }

  const lines = content.trim().split('\n');
  const firstLine = lines[0].trim();

  // 检查首行是否是 # 开头的标题
  if (firstLine.startsWith('#')) {
    // 提取 # 后面的内容作为标题
    meta.title = firstLine.replace(/^#+\s*/, '').trim();
  } else {
    // 如果不是 # 开头，截取开头的几个字符作为描述
    const textContent = content
      .replace(/[#*`\-\[\]()]/g, '') // 移除 Markdown 标记符号
      .replace(/\n+/g, ' ') // 将换行符替换为空格
      .replace(/\s+/g, ' ') // 合并多个空白字符
      .trim();

    if (textContent) {
      // 截取前6个字符作为描述
      meta.title = textContent.substring(0, 6);
    }
  }

  return meta;
}

/**
 * 从 Draw XML 内容中解析元数据
 */
function parseDrawMeta(content: string): {
  title?: string;
  elements?: number;
  [key: string]: any;
} {
  const meta: any = {};

  if (!content || !content.trim()) {
    return meta;
  }

  try {
    // 尝试解析 XML 内容，提取基本信息
    const parser = new DOMParser();
    const doc = parser.parseFromString(content, 'text/xml');

    // 检查是否有解析错误
    const parseError = doc.querySelector('parsererror');
    if (parseError) {
      // 如果 XML 解析失败，尝试从内容中提取基本信息
      const elementCount = (content.match(/<[^\/][^>]*>/g) || []).length;
      meta.elements = elementCount;
      meta.title = `绘图 (${elementCount} 个元素)`;
      return meta;
    }

    // 统计元素数量
    const allElements = doc.querySelectorAll('*');
    meta.elements = allElements.length;

    // 尝试从根元素或注释中提取标题
    const rootElement = doc.documentElement;
    if (rootElement) {
      const titleAttr =
        rootElement.getAttribute('title') ||
        rootElement.getAttribute('name') ||
        rootElement.getAttribute('label');
      if (titleAttr) {
        meta.title = titleAttr;
      } else {
        meta.title = `绘图 (${meta.elements} 个元素)`;
      }
    }
  } catch (error) {
    console.warn('解析 Draw XML 内容失败:', error);
    // 降级处理：简单统计标签数量
    const elementCount = (content.match(/<[^\/][^>]*>/g) || []).length;
    meta.elements = elementCount;
    meta.title = `绘图 (${elementCount} 个元素)`;
  }

  return meta;
}

/**
 * 处理新建类型文件
 */
async function handleNewTypeFile(
  projectId: string,
  path: string,
  content: any,
): Promise<{ typeEntity?: ITypeEntity; complianceResult?: any }> {
  const fileInfo = getFileInfoFromPath(path, content);

  // 从文件内容中解析元数据
  const parsedMeta = parseTypeScriptMeta(content);

  let typeEntity: ITypeEntity;

  // 使用配置系统推断文件类型，优先使用推断的类型
  const fileTypeManager = FileTypeManager.getInstance();
  const inferredType = fileTypeManager.inferTypeFromPath(path);

  // 根据推断的类型确定处理逻辑，如果无法推断则使用扩展名作为降级方案
  const typeToHandle = fileInfo.type || inferredType || fileInfo.extName;

  switch (typeToHandle) {
    case 'vo':
      // VO 类型，尝试解析 TypeScript 类型
      try {
        const voEntity = await parseTsType(content, 'object');
        if (typeof voEntity === 'object') {
          typeEntity = {
            ...voEntity,
            type: 'vo',
            name: fileInfo.name,
            desc: parsedMeta.title || fileInfo.desc, // 优先使用解析出的标题
            intro: parsedMeta.intro, // 添加详细介绍
            folder: fileInfo.folder,
            source: content,
          } as ITypeEntity;
        } else {
          // 解析失败，使用基础类型
          typeEntity = createBaseTypeFromPath(projectId, path, content, fileInfo);
          // 仍然尝试使用解析出的元数据
          if (parsedMeta.title) typeEntity.desc = parsedMeta.title;
          if (parsedMeta.intro) typeEntity.intro = parsedMeta.intro;
        }
      } catch (error) {
        console.warn('解析 VO 类型失败，使用基础类型:', error);
        typeEntity = createBaseTypeFromPath(projectId, path, content, fileInfo);
        // 仍然尝试使用解析出的元数据
        if (parsedMeta.title) typeEntity.desc = parsedMeta.title;
        if (parsedMeta.intro) typeEntity.intro = parsedMeta.intro;
      }
      break;
    case 'code': {
      // Markdown 文档类型，解析内容获取标题
      const markdownMeta = parseMarkdownMeta(content);
      typeEntity = {
        type: 'code',
        name: fileInfo.name,
        desc: markdownMeta.title || fileInfo.desc, // 优先使用解析出的标题
        folder: fileInfo.folder,
        source: content,
        language: 'markdown',
      };
      break;
    }
    case 'api':
      // API 类型，尝试解析 API 定义
      try {
        typeEntity = await codeToApiTypeEntity(content);
        typeEntity.name = fileInfo.name;
        typeEntity.desc = parsedMeta.title || fileInfo.desc; // 优先使用解析出的标题
        typeEntity.intro = parsedMeta.intro; // 添加详细介绍
        typeEntity.folder = fileInfo.folder;
        typeEntity.source = content;
        // 如果解析出了 API 信息，更新相关字段
        if (parsedMeta.method) typeEntity.method = parsedMeta.method;
        if (parsedMeta.uri) typeEntity.uri = parsedMeta.uri;
      } catch (error) {
        console.warn('解析 API 类型失败，使用基础类型:', error);
        typeEntity = createBaseTypeFromPath(projectId, path, content, fileInfo);
        // 仍然尝试使用解析出的元数据
        if (parsedMeta.title) typeEntity.desc = parsedMeta.title;
        if (parsedMeta.intro) typeEntity.intro = parsedMeta.intro;
      }
      break;
    case 'action':
      // 工具函数类型
      try {
        typeEntity = {
          source: content,
          code: {
            type: 'JSFunction',
            value: content,
          },
          type: 'action',
          name: fileInfo.name,
          desc: parsedMeta.title || fileInfo.desc, // 优先使用解析出的标题
          intro: parsedMeta.intro, // 添加详细介绍
          folder: fileInfo.folder,
        };
      } catch (error) {
        console.warn('解析工具函数类型失败，使用基础类型:', error);
        typeEntity = createBaseTypeFromPath(projectId, path, content, fileInfo);
        // 仍然尝试使用解析出的元数据
        if (parsedMeta.title) typeEntity.desc = parsedMeta.title;
        if (parsedMeta.intro) typeEntity.intro = parsedMeta.intro;
      }
      break;
    case 'cloud_function':
      // 云函数类型
      try {
        // 将文件名中的管道符 | 转换为斜杠 / 作为云函数路径
        const cloudFunctionPath = fileInfo.name.replace(/\|/g, '/');

        typeEntity = {
          source: content,
          type: 'cloud_function',
          name: cloudFunctionPath, // 使用转换后的路径作为 name
          desc: parsedMeta.title || fileInfo.desc, // 优先使用解析出的标题
          intro: parsedMeta.intro, // 添加详细介绍
          folder: fileInfo.folder,
          data: {
            methods: parsedMeta.methods || [], // 支持的 HTTP 方法
          },
        };
      } catch (error) {
        console.warn('解析云函数类型失败，使用基础类型:', error);
        typeEntity = createBaseTypeFromPath(projectId, path, content, fileInfo);
        // 对于基础类型也要进行路径转换
        if (typeEntity.type === 'cloud_function') {
          typeEntity.name = fileInfo.name.replace(/\|/g, '/');
        }
        // 仍然尝试使用解析出的元数据
        if (parsedMeta.title) typeEntity.desc = parsedMeta.title;
        if (parsedMeta.intro) typeEntity.intro = parsedMeta.intro;
        if (parsedMeta.methods) {
          typeEntity.data = { methods: parsedMeta.methods };
        }
      }
      break;
    case 'action.ts':
      // 动作函数类型（与 util.ts 类似）
      try {
        typeEntity = {
          source: content,
          code: {
            type: 'JSFunction',
            value: content,
          },
          type: 'action',
          name: fileInfo.name,
          desc: parsedMeta.title || fileInfo.desc, // 优先使用解析出的标题
          intro: parsedMeta.intro, // 添加详细介绍
          folder: fileInfo.folder,
        };
      } catch (error) {
        console.warn('解析动作函数类型失败，使用基础类型:', error);
        typeEntity = createBaseTypeFromPath(projectId, path, content, fileInfo);
        // 仍然尝试使用解析出的元数据
        if (parsedMeta.title) typeEntity.desc = parsedMeta.title;
        if (parsedMeta.intro) typeEntity.intro = parsedMeta.intro;
      }
      break;
    case 'data.ts':
      // 常量数据类型
      try {
        typeEntity = {
          source: content,
          type: 'constants',
          name: fileInfo.name,
          desc: parsedMeta.title || fileInfo.desc, // 优先使用解析出的标题
          intro: parsedMeta.intro, // 添加详细介绍
          folder: fileInfo.folder,
        };
      } catch (error) {
        console.warn('解析常量数据类型失败，使用基础类型:', error);
        typeEntity = createBaseTypeFromPath(projectId, path, content, fileInfo);
        // 仍然尝试使用解析出的元数据
        if (parsedMeta.title) typeEntity.desc = parsedMeta.title;
        if (parsedMeta.intro) typeEntity.intro = parsedMeta.intro;
      }
      break;
    case 'draw': {
      // Draw 绘图类型，解析 XML 内容获取元数据
      const drawMeta = parseDrawMeta(content);
      typeEntity = {
        type: 'draw',
        name: fileInfo.name,
        desc: drawMeta.title || fileInfo.desc, // 优先使用解析出的标题
        folder: fileInfo.folder,
        source: content,
        language: 'xml',
        data: {
          elements: drawMeta.elements || 0,
          format: 'xml',
          type: 'draw',
        },
      };
      break;
    }
    case 'typescript': {
      // TypeScript 文件类型
      const timestamp = Date.now();
      typeEntity = {
        type: 'typescript',
        name: fileInfo.name,
        desc: parsedMeta.title || fileInfo.desc || 'TypeScript 文件',
        intro: parsedMeta.intro,
        folder: fileInfo.folder,
        folderPath: fileInfo.folder,
        projectId,
        source: content,
        language: 'typescript',
        create_time: timestamp,
        update_time: timestamp,
        data: {
          format: 'typescript',
          type: 'code',
        },
      } as ITypeEntity;
      break;
    }
    case 'javascript': {
      // JavaScript 文件类型
      const timestamp = Date.now();
      typeEntity = {
        type: 'javascript',
        name: fileInfo.name,
        desc: parsedMeta.title || fileInfo.desc || 'JavaScript 文件',
        intro: parsedMeta.intro,
        folder: fileInfo.folder,
        folderPath: fileInfo.folder,
        projectId,
        source: content,
        language: 'javascript',
        create_time: timestamp,
        update_time: timestamp,
        data: {
          format: 'javascript',
          type: 'code',
        },
      } as ITypeEntity;
      break;
    }
    case 'text': {
      // 文本文件类型
      const timestamp = Date.now();
      typeEntity = {
        type: 'text',
        name: fileInfo.name,
        desc: fileInfo.desc || '文本文件',
        folder: fileInfo.folder,
        folderPath: fileInfo.folder,
        projectId,
        source: content,
        language: 'text',
        create_time: timestamp,
        update_time: timestamp,
        data: {
          format: 'text',
          type: 'document',
          wordCount: content.length,
        },
      } as ITypeEntity;
      break;
    }
    case 'sql': {
      // SQL 文件类型
      const timestamp = Date.now();
      typeEntity = {
        type: 'sql',
        name: fileInfo.name,
        desc: parsedMeta.title || fileInfo.desc || 'SQL 文件',
        intro: parsedMeta.intro,
        folder: fileInfo.folder,
        folderPath: fileInfo.folder,
        projectId,
        source: content,
        language: 'sql',
        create_time: timestamp,
        update_time: timestamp,
        data: {
          format: 'sql',
          type: 'database',
        },
      } as ITypeEntity;
      break;
    }
    case 'json': {
      // JSON 文件类型
      let jsonData = {};
      try {
        jsonData = JSON.parse(content);
      } catch (error) {
        console.warn('JSON 解析失败，使用空对象:', error);
      }

      const timestamp = Date.now();
      typeEntity = {
        type: 'json',
        name: fileInfo.name,
        desc: fileInfo.desc || 'JSON 配置文件',
        folder: fileInfo.folder,
        folderPath: fileInfo.folder,
        projectId,
        source: content,
        language: 'json',
        create_time: timestamp,
        update_time: timestamp,
        data: {
          format: 'json',
          type: 'config',
          keys:
            typeof jsonData === 'object' && jsonData !== null
              ? Object.keys(jsonData).length
              : 0,
          structure:
            typeof jsonData === 'object' && jsonData !== null
              ? Array.isArray(jsonData)
                ? 'array'
                : 'object'
              : typeof jsonData,
        },
      } as ITypeEntity;
      break;
    }
    default:
      // 降级处理：如果配置中没有对应的类型，尝试根据扩展名处理
      switch (fileInfo.extName) {
        case 'm.ts':
          // VO 类型降级处理
          try {
            const voEntity = await parseTsType(content, 'object');
            if (typeof voEntity === 'object') {
              typeEntity = {
                ...voEntity,
                name: fileInfo.name,
                desc: parsedMeta.title || fileInfo.desc,
                intro: parsedMeta.intro,
                folder: fileInfo.folder,
                source: content,
              };
            } else {
              typeEntity = createBaseTypeFromPath(projectId, path, content, fileInfo);
            }
          } catch (error) {
            console.warn('解析 VO 类型失败，使用基础类型:', error);
            typeEntity = createBaseTypeFromPath(projectId, path, content, fileInfo);
          }
          break;
        case 'api.ts':
          // API 类型降级处理
          try {
            typeEntity = await codeToApiTypeEntity(content);
            typeEntity.name = fileInfo.name;
            typeEntity.desc = parsedMeta.title || fileInfo.desc;
            typeEntity.intro = parsedMeta.intro;
          } catch (error) {
            console.warn('解析 API 类型失败，使用基础类型:', error);
            typeEntity = createBaseTypeFromPath(projectId, path, content, fileInfo);
          }
          break;
        case 'util.ts':
          typeEntity = {
            source: content,
            code: {
              type: 'JSFunction',
              value: content,
            },
            type: 'action',
            name: fileInfo.name,
            desc: parsedMeta.title || fileInfo.desc,
            intro: parsedMeta.intro,
            folder: fileInfo.folder,
          };
          break;
        case 'action.ts':
          // 工具函数/动作函数降级处理
          typeEntity = {
            source: content,
            code: {
              type: 'JSFunction',
              value: content,
            },
            type: 'action',
            name: fileInfo.name,
            desc: parsedMeta.title || fileInfo.desc,
            intro: parsedMeta.intro,
            folder: fileInfo.folder,
          };
          break;
        case 'node.ts':
          // 云函数降级处理
          const cloudFunctionPath = fileInfo.name.replace(/\|/g, '/');
          typeEntity = {
            source: content,
            code: {
              type: 'JSFunction',
              value: content,
            },
            type: 'cloud_function',
            name: cloudFunctionPath,
            desc: parsedMeta.title || fileInfo.desc,
            intro: parsedMeta.intro,
            folder: fileInfo.folder,
          };
          break;
        case 'md':
          // Markdown 降级处理
          const markdownMeta = parseMarkdownMeta(content);
          typeEntity = {
            type: 'code',
            name: fileInfo.name,
            desc: markdownMeta.title || fileInfo.desc,
            folder: fileInfo.folder,
            source: content,
            language: 'markdown',
          };
          break;
        default:
          // 使用工厂函数创建基础类型实体
          typeEntity = createBaseTypeFromPath(projectId, path, content, fileInfo);
          // 对于通用代码文件，也尝试解析元数据
          if (parsedMeta.title) typeEntity.desc = parsedMeta.title;
          if (parsedMeta.intro) typeEntity.intro = parsedMeta.intro;
      }
  }

  // 设置项目ID
  typeEntity.projectId = projectId;

  return {
    typeEntity,
  };
}

export const validateAndUpdateType = async (
  projectId: string,
  path: string,
  content: any,
  options: {
    existTypeEntity?: ITypeEntity;
    encoding?: string;
    mode?: number;
    flag?: string;
  } = {},
): Promise<{ typeEntity?: ITypeEntity; complianceResult?: any }> => {
  // console.log('validateAndUpdateType: ');

  let { existTypeEntity } = options;

  console.log(
    'validateAndUpdateType: ',
    path,
    content,
    existTypeEntity ? 'existing' : 'new',
  );

  // 如果没有传入现有类型实体，当作新建文件处理
  if (!existTypeEntity) {
    console.log('没有现有类型实体，创建新文件:', path);
    return await handleNewTypeFile(projectId, path, content);
  }

  // 从文件内容中解析元数据
  const parsedMeta = parseTypeScriptMeta(content);

  // 复制现有的类型实体并更新
  const typeItem = { ...existTypeEntity };

  if (
    [
      'cloud_function',
      'action',
      'code',
      'draw',
      'flow',
      'typescript',
      'javascript',
      'text',
      'sql',
      'json',
    ].includes(typeItem.type)
  ) {
    typeItem.source = content;
    typeItem.update_time = Date.now();

    // 对于云函数，需要从路径中解析文件信息并转换路径
    if (typeItem.type === 'cloud_function') {
      const fileInfo = getFileInfoFromPath(path, content);

      // 如果文件名包含管道符，说明是新的路径格式，需要转换
      if (fileInfo.name.includes('|')) {
        typeItem.name = fileInfo.name.replace(/\|/g, '/');
      }
    }

    // 根据不同类型使用不同的元数据解析方式
    if (typeItem.type === 'code' && path.endsWith('.md')) {
      if (!typeItem.language) {
        typeItem.language = 'markdown';
      }
      // Markdown 文档使用专门的解析逻辑
      const markdownMeta = parseMarkdownMeta(content);
      if (markdownMeta.title) typeItem.desc = markdownMeta.title;
    } else if (typeItem.type === 'draw' && path.endsWith('.draw')) {
      if (!typeItem.language) {
        typeItem.language = 'xml';
      }
      // Draw 绘图使用专门的解析逻辑
      const drawMeta = parseDrawMeta(content);
      if (drawMeta.title) typeItem.desc = drawMeta.title;
      // 更新绘图数据
      typeItem.data = {
        ...typeItem.data,
        elements: drawMeta.elements || 0,
        format: 'xml',
        type: 'draw',
      };
    } else if (typeItem.type === 'flow' && path.endsWith('.flow')) {
      if (!typeItem.language) {
        typeItem.language = 'json';
      }
      // Flow 协作画布使用 JSON 解析逻辑
      try {
        const flowData = JSON.parse(content);
        if (flowData.nodes && flowData.edges) {
          typeItem.data = {
            ...typeItem.data,
            nodeCount: flowData.nodes.length || 0,
            edgeCount: flowData.edges.length || 0,
            viewport: flowData.viewport,
            format: 'json',
            type: 'flow',
          };
        }
      } catch (error) {
        console.warn('解析 Flow 数据失败:', error);
      }
    } else if (['typescript', 'javascript'].includes(typeItem.type)) {
      // TypeScript/JavaScript 代码使用通用的解析逻辑
      if (parsedMeta.title) typeItem.desc = parsedMeta.title;
      if (parsedMeta.intro) typeItem.intro = parsedMeta.intro;
      // 更新语言类型
      if (!typeItem.language) {
        typeItem.language = typeItem.type;
      }
      // 更新数据信息
      typeItem.data = {
        ...typeItem.data,
        format: typeItem.type,
        type: 'code',
      };
    } else if (typeItem.type === 'text') {
      // 文本文件处理
      if (!typeItem.language) {
        typeItem.language = 'text';
      }
      // 更新数据信息
      typeItem.data = {
        ...typeItem.data,
        format: 'text',
        type: 'document',
        wordCount: content.length,
      };
    } else if (typeItem.type === 'sql') {
      // SQL 文件处理
      if (parsedMeta.title) typeItem.desc = parsedMeta.title;
      if (parsedMeta.intro) typeItem.intro = parsedMeta.intro;
      if (!typeItem.language) {
        typeItem.language = 'sql';
      }
      // 更新数据信息
      typeItem.data = {
        ...typeItem.data,
        format: 'sql',
        type: 'database',
      };
    } else if (typeItem.type === 'json') {
      // JSON 文件处理
      if (!typeItem.language) {
        typeItem.language = 'json';
      }
      // 解析 JSON 数据并更新信息
      try {
        const jsonData = JSON.parse(content);
        typeItem.data = {
          ...typeItem.data,
          format: 'json',
          type: 'config',
          keys:
            typeof jsonData === 'object' && jsonData !== null
              ? Object.keys(jsonData).length
              : 0,
          structure:
            typeof jsonData === 'object' && jsonData !== null
              ? Array.isArray(jsonData)
                ? 'array'
                : 'object'
              : typeof jsonData,
        };
      } catch (error) {
        console.warn('JSON 解析失败:', error);
        typeItem.data = {
          ...typeItem.data,
          format: 'json',
          type: 'config',
          keys: 0,
          structure: 'invalid',
        };
      }
    } else {
      // 其他类型使用通用的解析逻辑
      if (parsedMeta.title) typeItem.desc = parsedMeta.title;
      if (parsedMeta.intro) typeItem.intro = parsedMeta.intro;
    }

    if (typeItem.type === 'action') {
      typeItem.code = {
        type: 'JSFunction',
        value: content,
      };
    }

    if (typeItem.type === 'cloud_function' && parsedMeta.methods) {
      typeItem.data = { ...typeItem.data, methods: parsedMeta.methods };
    }

    return {
      typeEntity: typeItem,
    };
  }
  if (typeItem.type === 'vo') {
    const typeEntity = await parseTsType(content, 'object');
    if (typeof typeEntity === 'object') {
      // 更新元数据
      if (parsedMeta.title) typeEntity.desc = parsedMeta.title;
      if (parsedMeta.intro) typeEntity.intro = parsedMeta.intro;
      typeEntity.source = content;
      typeEntity.update_time = Date.now();

      return {
        typeEntity,
      };
    }
  }
  if (typeItem.type === 'api') {
    const typeEntity = await codeToApiTypeEntity(content);

    // 更新元数据
    if (parsedMeta.title) typeEntity.desc = parsedMeta.title;
    if (parsedMeta.intro) typeEntity.intro = parsedMeta.intro;
    if (parsedMeta.method) typeEntity.method = parsedMeta.method;
    if (parsedMeta.uri) typeEntity.uri = parsedMeta.uri;
    typeEntity.source = content;
    typeEntity.update_time = Date.now();

    return {
      typeEntity,
    };
  }

  // 默认返回更新后的类型实体
  return {
    typeEntity: typeItem,
  };
};
